package Download

import (
	"MerelybG/Common"
	"bytes"
	"crypto/sha1"
	"database/sql"
	"fmt"
	"github.com/jackpal/bencode-go"
	"io"
	"net"
	"net/http"
	"os"
	"time"
)

type FileDict struct {
	Length int64    "length"
	Path   []string "path"
	Md5sum string   "md5sum"
}

type InfoDict struct {
	FileDuration []int64 "file-duration"
	FileMedia    []int64 "file-media"

	// Single file
	Name   string "name"
	Length int64  "length"
	Md5sum string "md5sum"

	// Multiple files
	Files       []FileDict "files"
	PieceLength int64      "piece length"
	Pieces      string     "pieces"
	Private     int64      "private"
}

type MetaInfo struct {
	Info         InfoDict   "info"
	InfoHash     string     "info hash"
	Announce     string     "announce"
	AnnounceList [][]string "announce-list"
	CreationDate int64      "creation date"
	Comment      string     "comment"
	CreatedBy    string     "created by"
	Encoding     string     "encoding"
}

var timeout = time.Duration(2 * time.Second)

func dialTimeout(network, addr string) (net.Conn, error) {
	return net.DialTimeout(network, addr, timeout)
}

func pullTorrent(url string) (int, error) {

	req, err := http.NewRequest("GET", url, nil)
	if err != nil {
		return 1, err
	}

	req.Header.Add("User-Agent", "Mozilla/5.0")
	req.Header.Add("Host", "bt.box.n0808.com")
	req.Header.Add("Accept", "*/*")
	req.Header.Add("Connection", "Keep-Alive")

	transport := http.Transport{
		Dial: dialTimeout,
	}

	client := &http.Client{
		Transport: &transport,
	}

	resp, err := client.Do(req)

	if err != nil {
		return 2, err
	}
	defer resp.Body.Close()

	var metaTorrent MetaInfo
	ok := metaTorrent.ReadTorrentMetaInfoFile(resp.Body)
	if !ok {
		return 3, nil
	}

	name := metaTorrent.Info.Name
	hashInfo := fmt.Sprintf("%X", metaTorrent.InfoHash)
	created := metaTorrent.CreationDate

	var fileLength int64
	var fileDownLoadList bytes.Buffer
	var fileList string

	for _, fileDict := range metaTorrent.Info.Files {
		fileLength += fileDict.Length
		for _, path := range fileDict.Path {
			fileDownLoadList.WriteString(path)
			fileDownLoadList.WriteString("\r\n")
		}
	}
	fileList = fileDownLoadList.String()

	var fileLengthTotal int64
	if fileLength > 0 {
		fileLengthTotal = fileLength / (1024 * 1024)
	}

	if fileLengthTotal > 0 {
		db, err := sql.Open("mysql", "root:admin@tcp(127.0.0.1:3306)/678BT?charset=utf8&timeout=3s")
		if err != nil {
			return 4, err
		}
		defer db.Close()

		stmtIns, err := db.Prepare("INSERT INTO magnet (hashinfo,name,files,length,created,indexd) VALUES(?,?,?,?,?,?)")
		if err != nil {
			return 5, err
		}
		defer stmtIns.Close()

		timestamp := time.Now().Unix()
		_, error := stmtIns.Exec(hashInfo, name, fileList, fileLengthTotal, created, timestamp)
		if error != nil {
			return 6, error
		}
	}

	return 0, nil
}

func (metaInfo *MetaInfo) ReadTorrentMetaInfoFile(r io.Reader) bool {

	fileMetaData, er := bencode.Decode(r)
	if er != nil {
		return false
	}

	metaInfoMap, ok := fileMetaData.(map[string]interface{})
	if !ok {
		return false
	}

	var bytesBuf bytes.Buffer
	for mapKey, mapVal := range metaInfoMap {
		switch mapKey {
		case "info":
			if er = bencode.Marshal(&bytesBuf, mapVal); er != nil {
				return false
			}

			infoHash := sha1.New()
			infoHash.Write(bytesBuf.Bytes())
			metaInfo.InfoHash = string(infoHash.Sum(nil))

			if er = bencode.Unmarshal(&bytesBuf, &metaInfo.Info); er != nil {
				return false
			}

		case "announce-list":
			if er = bencode.Marshal(&bytesBuf, mapVal); er != nil {
				return false
			}
			if er = bencode.Unmarshal(&bytesBuf, &metaInfo.AnnounceList); er != nil {
				return false
			}

		case "announce":
			if aa, ok := mapVal.(string); ok {
				metaInfo.Announce = aa
			}

		case "creation date":

			if tt, ok := mapVal.(int64); ok {
				metaInfo.CreationDate = tt
			}

		case "comment":
			if cc, ok := mapVal.(string); ok {
				metaInfo.Comment = cc
			}

		case "created by":
			if cb, ok := mapVal.(string); ok {
				metaInfo.CreatedBy = cb
			}

		case "encoding":
			if ed, ok := mapVal.(string); ok {
				metaInfo.Encoding = ed
			}
		}
	}

	return true

}

func ParseTorrent(strUrl string) int {

	f, err := os.Open(strUrl)
	Common.CheckErr("ParseTorrent", err)
	var metaTorrent MetaInfo
	ok := metaTorrent.ReadTorrentMetaInfoFile(f)
	fmt.Println(ok)
	return 0
}

//
//func pullTorrent(url string) (int, error) {
//
//	req, err := http.NewRequest("GET", url, nil)
//	if err != nil {
//		return 1, err
//	}
//
//	req.Header.Add("User-Agent", "Mozilla/5.0")
//	req.Header.Add("Host", "bt.box.n0808.com")
//	req.Header.Add("Accept", "*/*")
//	req.Header.Add("Connection", "Keep-Alive")
//
//	transport := http.Transport{
//		Dial: dialTimeout,
//	}
//
//	client := &http.Client{
//		Transport: &transport,
//	}
//
//	resp, err := client.Do(req)
//
//	if err != nil {
//		return 2, err
//	}
//	defer resp.Body.Close()
//
//	var metaTorrent MetaInfo
//	ok := metaTorrent.ReadTorrentMetaInfoFile(resp.Body)
//	if !ok {
//		return 3, nil
//	}
//
//	name := metaTorrent.Info.Name
//	hashInfo := fmt.Sprintf("%X", metaTorrent.InfoHash)
//	created := metaTorrent.CreationDate
//
//	var fileLength int64
//	var fileDownLoadList bytes.Buffer
//	var fileList string
//
//	for _, fileDict := range metaTorrent.Info.Files {
//		fileLength += fileDict.Length
//		for _, path := range fileDict.Path {
//			fileDownLoadList.WriteString(path)
//			fileDownLoadList.WriteString("\r\n")
//		}
//	}
//	fileList = fileDownLoadList.String()
//
//	var fileLengthTotal int64
//	if fileLength > 0 {
//		fileLengthTotal = fileLength / (1024 * 1024)
//	}
//
//	if fileLengthTotal > 0 {
//		db, err := sql.Open("mysql", "root:admin@tcp(127.0.0.1:3306)/678BT?charset=utf8&timeout=3s")
//		if err != nil {
//			return 4, err
//		}
//		defer db.Close()
//
//		stmtIns, err := db.Prepare("INSERT INTO magnet (hashinfo,name,files,length,created,indexd) VALUES(?,?,?,?,?,?)")
//		if err != nil {
//			return 5, err
//		}
//		defer stmtIns.Close()
//
//		timestamp := time.Now().Unix()
//		_, error := stmtIns.Exec(hashInfo, name, fileList, fileLengthTotal, created, timestamp)
//		if error != nil {
//			return 6, error
//		}
//	}
//
//	return 0, nil
//}
